img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Les tuples en Python : définition, création et utilisation

Ce tutoriel a pour objectif d’expliquer ce qu’est un tuple en Python et comment l’utiliser efficacement. Vous apprendrez à créer, modifier et parcourir des tuples, tout en découvrant leurs avantages par rapport aux listes. L’objectif est de vous rendre autonome dans leur manipulation au quotidien.

Introduction aux tuples en Python

Les tuples sont des structures de données fondamentales en Python qui permettent de stocker des collections ordonnées et immuables d'éléments. Ils sont largement utilisés pour regrouper des données liées de manière efficace et sécurisée.

Définition d'un tuple

Un tuple est une séquence ordonnée d'éléments qui ne peut pas être modifiée après sa création (immuable). Les tuples sont définis avec des parenthèses et peuvent contenir des éléments de types différents.

definition_tuple.py
# Création de tuples de base
					# Tuple vide
					tuple_vide = ()
					print(f"Tuple vide: {tuple_vide}")
					
					# Tuple avec des villes marocaines
					villes_maroc = ("Casablanca", "Rabat", "Marrakech", "Fès")
					print(f"Villes du Maroc: {villes_maroc}")
					
					# Tuple avec différents types de données
					informations_ville = ("Marrakech", 928850, 230, True)  # nom, population, altitude, capitale régionale
					print(f"Informations sur Marrakech: {informations_ville}")
					
					# Tuple sans parenthèses (packing)
					coordonnees_maroc = 31.7917, -7.0926, "Afrique du Nord"
					print(f"Coordonnées géographiques: {coordonnees_maroc}")
					print(f"Type: {type(coordonnees_maroc)}")
					
					# Vérification du type
					print(f"villes_maroc est un tuple: {isinstance(villes_maroc, tuple)}")

Différences entre tuple et liste

Bien que les tuples et les listes semblent similaires, ils présentent des différences fondamentales qui déterminent leur utilisation appropriée dans différents contextes.

differences_tuple_liste.py
# Comparaison entre tuple et liste
					# DIFFÉRENCE 1: Mutabilité
					liste_villes = ["Tanger", "Tétouan", "Chefchaouen"]
					tuple_villes = ("Tanger", "Tétouan", "Chefchaouen")
					
					# Liste: modifiable
					liste_villes[0] = "Tanger-Med"  # OK
					liste_villes.append("Asilah")  # OK
					print(f"Liste modifiée: {liste_villes}")
					
					# Tuple: non modifiable
					# tuple_villes[0] = "Tanger-Med"  # Erreur: TypeError
					# tuple_villes.append("Asilah")   # Erreur: AttributeError
					
					# DIFFÉRENCE 2: Performance
					import sys
					print(f"\nTaille mémoire liste: {sys.getsizeof(liste_villes)} octets")
					print(f"Taille mémoire tuple: {sys.getsizeof(tuple_villes)} octets")
					
					# DIFFÉRENCE 3: Utilisation comme clés de dictionnaire
					coordonnees_casablanca = (33.5731, -7.5898)
					coordonnees_rabat = (34.0209, -6.8416)
					
					villes_geo = {
					    coordonnees_casablanca: "Casablanca",
					    coordonnees_rabat: "Rabat"
					}
					print(f"\nDictionnaire avec tuples comme clés: {villes_geo}")
					
					# DIFFÉRENCE 4: Méthodes disponibles
					print(f"\nMéthodes de liste: {[method for method in dir(liste_villes) if not method.startswith('_')]}")
					print(f"Méthodes de tuple: {[method for method in dir(tuple_villes) if not method.startswith('_')]}")

Quand utiliser un tuple ?

Le choix entre tuple et liste dépend du contexte d'utilisation. Voici les situations où les tuples sont particulièrement appropriés :

utilisation_tuples.py
# CAS 1: Données immuables et constantes
					# Informations géographiques fixes du Maroc
					infos_maroc = ("Maroc", "Rabat", 446550, 37000000)  # pays, capitale, superficie, population
					print(f"Informations fixes: {infos_maroc}")
					
					# CAS 2: Retour multiple de fonctions
					def calculer_statistiques(donnees):
					    """Calcule plusieurs statistiques sur une liste de données"""
					    moyenne = sum(donnees) / len(donnees)
					    maximum = max(donnees)
					    minimum = min(donnees)
					    return moyenne, maximum, minimum  # Retourne un tuple
					
					# Températures mensuelles à Marrakech
					temperatures = [12, 14, 17, 20, 24, 28, 32, 32, 28, 23, 17, 13]
					stats = calculer_statistiques(temperatures)
					print(f"\nStatistiques des températures: {stats}")
					print(f"Type du retour: {type(stats)}")
					
					# CAS 3: Clés de dictionnaire (car immuables)
					regions_maroc = {
					    ("Casablanca", "Settat"): "Région Casablanca-Settat",
					    ("Rabat", "Salé", "Kénitra"): "Région Rabat-Salé-Kénitra",
					    ("Marrakech", "Safi"): "Région Marrakech-Safi"
					}
					print(f"\nRégions du Maroc: {regions_maroc}")
					
					# CAS 4: Sécurité des données
					class SystemeAuthentification:
					    def __init__(self):
					        # Tuple pour stocker les rôles fixes d'un utilisateur
					        self.roles_utilisateur = ("lecture", "commentaire")
					    
					    def verifier_permissions(self):
					        # Les rôles ne peuvent pas être modifiés accidentellement
					        print(f"Rôles utilisateur: {self.roles_utilisateur}")
					
					auth = SystemeAuthentification()
					auth.verifier_permissions()
					
					# CAS 5: Données hétérogènes mais liées
					# Informations sur un produit marocain
					produit_marocain = ("Huile d'Argan", 150.0, "ML", True)  # nom, prix, devise, disponible
					nom, prix, devise, disponible = produit_marocain  # Déballage facile
					print(f"\nProduit: {nom}, Prix: {prix} {devise}, Disponible: {disponible}")

Création et syntaxe des tuples

La création de tuples en Python suit des règles syntaxiques spécifiques qui permettent de définir des collections immuables de manière efficace et intuitive. Comprendre ces règles est essentiel pour utiliser correctement les tuples dans vos programmes.

Créer un tuple vide ou avec des éléments

Les tuples peuvent être créés vides ou contenir un ou plusieurs éléments. La syntaxe utilise principalement les parenthèses, mais il existe aussi des méthodes alternatives.

creation_tuples.py
# Différentes méthodes pour créer des tuples
					
					# 1. Tuple vide
					tuple_vide = ()
					print(f"Tuple vide: {tuple_vide}")
					print(f"Type: {type(tuple_vide)}")
					print(f"Taille: {len(tuple_vide)} éléments")
					
					# 2. Tuple avec plusieurs éléments (villes impériales du Maroc)
					villes_imperiales = ("Marrakech", "Fès", "Meknès", "Rabat")
					print(f"\nVilles impériales: {villes_imperiales}")
					print(f"Nombre de villes: {len(villes_imperiales)}")
					
					# 3. Tuple sans parenthèses (tuple packing)
					specialites_culinaires = "Tajine", "Couscous", "Pastilla", "Harira"
					print(f"\nSpécialités culinaires marocaines: {specialites_culinaires}")
					print(f"Type: {type(specialites_culinaires)}")
					
					# 4. Tuple avec différents types de données
					info_casablanca = ("Casablanca", 3.359, 1912, True)  # ville, population (millions), année fondation, capitale économique
					print(f"\nInformations sur Casablanca: {info_casablanca}")
					print(f"Population: {info_casablanca[1]} millions")
					
					# 5. Tuple imbriqué (informations régionales)
					region_marrakech = ("Marrakech-Safi", 1394800, ("Marrakech", "Safi", "Essaouira"))
					print(f"\nRégion Marrakech-Safi: {region_marrakech}")
					print(f"Villes principales: {region_marrakech[2]}")
					
					# 6. Comparaison avec les listes
					liste_villes = ["Tanger", "Tétouan"]
					tuple_villes = ("Tanger", "Tétouan")
					print(f"\nListe: {liste_villes}, type: {type(liste_villes)}")
					print(f"Tuple: {tuple_villes}, type: {type(tuple_villes)}")

Tuple à un seul élément : la syntaxe particulière

La création d'un tuple avec un seul élément nécessite une syntaxe particulière pour éviter la confusion avec une simple expression entre parenthèses. Il faut ajouter une virgule après l'élément.

tuple_element_unique.py
# Syntaxe spéciale pour les tuples à un seul élément
					
					# ERREUR COURANTE : sans virgule, ce n'est pas un tuple
					pas_un_tuple = ("Casablanca")
					print(f"Sans virgule: {pas_un_tuple}")
					print(f"Type: {type(pas_un_tuple)}")  # C'est une chaîne de caractères!
					
					# CORRECT : avec virgule, c'est bien un tuple
					mon_tuple = ("Casablanca",)
					print(f"\nAvec virgule: {mon_tuple}")
					print(f"Type: {type(mon_tuple)}")  # Maintenant c'est un tuple
					print(f"Taille: {len(mon_tuple)} élément")
					
					# Exemples pratiques avec un seul élément
					capitale_maroc = ("Rabat",)
					plus_grande_ville = ("Casablanca",)
					ville_imperiale = ("Fès",)
					
					print(f"\nCapitale: {capitale_maroc}")
					print(f"Plus grande ville: {plus_grande_ville}")
					print(f"Ville impériale: {ville_imperiale}")
					
					# Tuple à un élément avec packing (sans parenthèses)
					ville_seule = "Marrakech",
					print(f"\nAvec packing: {ville_seule}")
					print(f"Type: {type(ville_seule)}")
					
					# Cas d'utilisation pratique : configuration unique
					config_site = ("https://www.visitmorocco.com",)
					langue_defaut = ("fr",)
					devise_nationale = ("MAD",)
					
					print(f"\nConfiguration site: {config_site}")
					print(f"Langue par défaut: {langue_defaut}")
					print(f"Devise: {devise_nationale}")
					
					# Vérification que c'est bien un tuple
					print(f"\nEst-ce un tuple? {isinstance(ville_seule, tuple)}")
					print(f"Est-ce un tuple? {isinstance(pas_un_tuple, tuple)}")

Conversion d'autres types en tuple (avec tuple())

La fonction tuple() permet de convertir d'autres types de séquences en tuples. C'est particulièrement utile pour transformer des listes, des chaînes de caractères ou d'autres itérables en collections immuables.

conversion_tuple.py
# Conversion de différents types en tuples
					
					# 1. Conversion depuis une liste (cas le plus courant)
					liste_villes = ["Agadir", "Dakhla", "Laayoune"]
					tuple_villes_cotieres = tuple(liste_villes)
					print(f"Liste originale: {liste_villes}")
					print(f"Tuple converti: {tuple_villes_cotieres}")
					print(f"Type: {type(tuple_villes_cotieres)}")
					
					# 2. Conversion depuis une chaîne de caractères
					nom_maroc = "Maroc"
					tuple_lettres = tuple(nom_maroc)
					print(f"\nChaîne: '{nom_maroc}'")
					print(f"Tuple des lettres: {tuple_lettres}")
					
					# 3. Conversion depuis un range (générateur)
					codes_postaux = tuple(range(10000, 10006))
					print(f"\nCodes postaux marocains: {codes_postaux}")
					
					# 4. Conversion depuis un dictionnaire (clés uniquement)
					regions_maroc = {
					    "Casablanca-Settat": 6.8,
					    "Rabat-Salé-Kénitra": 4.6,
					    "Marrakech-Safi": 4.3
					}
					tuple_regions = tuple(regions_maroc)
					print(f"\nDictionnaire des régions: {regions_maroc}")
					print(f"Tuple des noms de régions: {tuple_regions}")
					
					# 5. Conversion depuis un set (ensemble)
					plats_marocains = {"Tajine", "Couscous", "Pastilla", "Harira"}
					tuple_plats = tuple(plats_marocains)
					print(f"\nSet des plats: {plats_marocains}")
					print(f"Tuple des plats: {tuple_plats}")
					
					# 6. Cas pratique : sécuriser des données modifiables
					class SystemeConfiguration:
					    def __init__(self):
					        self.villes_configurables = ["Rabat", "Casablanca", "Marrakech"]
					    
					    def get_villes_fixes(self):
					        # Retourne un tuple pour empêcher la modification
					        return tuple(self.villes_configurables)
					
					config = SystemeConfiguration()
					villes_fixes = config.get_villes_fixes()
					print(f"\nVilles configurables (liste): {config.villes_configurables}")
					print(f"Villes fixes (tuple): {villes_fixes}")
					
					# 7. Conversion depuis un autre tuple (crée une copie)
					original = ("Fès", "Meknès")
					copie = tuple(original)
					print(f"\nTuple original: {original}")
					print(f"Copie du tuple: {copie}")
					print(f"Même objet? {original is copie}")  # True car les tuples sont immuables
					
					# 8. Conversion depuis un générateur
					def generateur_monuments():
					    monuments = ["Hassan II", "Koutoubia", "Tour Hassan"]
					    for monument in monuments:
					        yield monument
					
					tuple_monuments = tuple(generateur_monuments())
					print(f"\nMonuments marocains: {tuple_monuments}")

Accès et manipulation des éléments

Bien que les tuples soient immuables, Python offre plusieurs méthodes pour accéder à leurs éléments et les manipuler de manière non destructive. Ces opérations permettent de lire et traiter les données sans modifier le tuple original.

Accéder aux éléments par index

L'accès par index permet de récupérer des éléments spécifiques d'un tuple en utilisant leur position. Les indices commencent à 0 pour le premier élément et supportent également les indices négatifs pour compter depuis la fin.

acces_index.py
# Accès aux éléments par index avec des données marocaines
					
					# Tuple des villes impériales du Maroc
					villes_imperiales = ("Marrakech", "Fès", "Meknès", "Rabat")
					print(f"Villes impériales: {villes_imperiales}")
					
					# Accès par indices positifs (début à fin)
					print(f"\n--- Accès par indices positifs ---")
					print(f"Première ville (index 0): {villes_imperiales[0]}")
					print(f"Deuxième ville (index 1): {villes_imperiales[1]}")
					print(f"Troisième ville (index 2): {villes_imperiales[2]}")
					print(f"Quatrième ville (index 3): {villes_imperiales[3]}")
					
					# Accès par indices négatifs (fin à début)
					print(f"\n--- Accès par indices négatifs ---")
					print(f"Dernière ville (index -1): {villes_imperiales[-1]}")
					print(f"Avant-dernière ville (index -2): {villes_imperiales[-2]}")
					print(f"Deuxième depuis la fin (index -3): {villes_imperiales[-3]}")
					print(f"Première ville (index -4): {villes_imperiales[-4]}")
					
					# Tuple avec différents types de données (informations sur une ville)
					info_marrakech = ("Marrakech", 928850, 230, True, (31.63, -8.01))
					# nom, population, altitude, capitale_regionnelle, coordonnees
					
					print(f"\n--- Accès dans un tuple hétérogène ---")
					print(f"Nom de la ville: {info_marrakech[0]}")
					print(f"Population: {info_marrakech[1]} habitants")
					print(f"Altitude: {info_marrakech[2]} mètres")
					print(f"Capitale régionale: {info_marrakech[3]}")
					print(f"Coordonnées GPS: {info_marrakech[4]}")
					
					# Gestion des erreurs d'index
					print(f"\n--- Gestion des erreurs ---")
					try:
					    print(f"Index 10: {villes_imperiales[10]}")  # IndexError
					except IndexError as e:
					    print(f"Erreur: {e}")
					
					try:
					    print(f"Index -10: {villes_imperiales[-10]}")  # IndexError
					except IndexError as e:
					    print(f"Erreur: {e}")
					
					# Vérification de la longueur avant accès
					index_souhaite = 2
					if index_souhaite < len(villes_imperiales):
					    print(f"\nVille à l'index {index_souhaite}: {villes_imperiales[index_souhaite]}")
					else:
					    print(f"Index {index_souhaite} hors limites")

Slicing : extraire une portion de tuple

Le slicing permet d'extraire des sous-tuples en spécifiant une plage d'indices. La syntaxe tuple[début:fin:pas] offre une grande flexibilité pour travailler avec des portions de tuples.

slicing_tuples.py
# Slicing de tuples avec des données marocaines
					
					# Tuple des régions du Maroc
					regions_maroc = (
					    "Tanger-Tétouan-Al Hoceïma",
					    "Oriental",
					    "Fès-Meknès",
					    "Rabat-Salé-Kénitra",
					    "Béni Mellal-Khénifra",
					    "Casablanca-Settat",
					    "Marrakech-Safi",
					    "Drâa-Tafilalet",
					    "Souss-Massa",
					    "Guelmim-Oued Noun",
					    "Laâyoune-Sakia El Hamra",
					    "Dakhla-Oued Ed-Dahab"
					)
					
					print(f"Toutes les régions ({len(regions_maroc)}): {regions_maroc}")
					
					# Slicing de base [start:stop]
					print(f"\n--- Slicing de base ---")
					print(f"3 premières régions [0:3]: {regions_maroc[0:3]}")
					print(f"Régions du milieu [4:8]: {regions_maroc[4:8]}")
					print(f"4 dernières régions [-4:]: {regions_maroc[-4:]}")
					
					# Slicing avec step [start:stop:step]
					print(f"\n--- Slicing avec pas ---")
					print(f"Régions paires [::2]: {regions_maroc[::2]}")
					print(f"Régions impaires [1::2]: {regions_maroc[1::2]}")
					print(f"Toutes les 3 régions [::3]: {regions_maroc[::3]}")
					
					# Slicing avec indices négatifs
					print(f"\n--- Slicing avec indices négatifs ---")
					print(f"Exclure les 2 dernières [:-2]: {regions_maroc[:-2]}")
					print(f"De l'avant-dernière à la fin [-2:]: {regions_maroc[-2:]}")
					print(f"De -6 à -2 [-6:-2]: {regions_maroc[-6:-2]}")
					
					# Slicing pour inverser un tuple
					print(f"\n--- Inversion avec slicing ---")
					print(f"Régions inversées [::-1]: {regions_maroc[::-1]}")
					print(f"Inversé avec pas de 2 [::-2]: {regions_maroc[::-2]}")
					
					# Cas pratiques avec slicing
					print(f"\n--- Cas pratiques ---")
					
					# Extraire les régions du Nord
					regions_nord = regions_maroc[:4]
					print(f"Régions du Nord: {regions_nord}")
					
					# Extraire les régions du Sud
					regions_sud = regions_maroc[-4:]
					print(f"Régions du Sud: {regions_sud}")
					
					# Slicing avec des variables
					debut = 2
					fin = 7
					pas = 2
					selection = regions_maroc[debut:fin:pas]
					print(f"Sélection [2:7:2]: {selection}")
					
					# Slicing qui retourne un tuple vide
					vide = regions_maroc[5:2]  # start > stop sans pas négatif
					print(f"Slice vide [5:2]: {vide}")
					
					# Vérification que le slicing crée un nouveau tuple
					original = ("A", "B", "C")
					slice_result = original[0:2]
					print(f"\nOriginal: {original}, id: {id(original)}")
					print(f"Slice: {slice_result}, id: {id(slice_result)}")
					print(f"Même objet? {original is slice_result}")

Parcourir un tuple avec une boucle

Le parcours des tuples avec des boucles permet de traiter chaque élément séquentiellement. Python offre plusieurs méthodes pour itérer sur les tuples, adaptées à différents besoins.

parcours_tuples.py
# Parcours de tuples avec des données marocaines
					
					# Tuple des monuments historiques marocains
					monuments_maroc = (
					    "Mosquée Hassan II",
					    "Koutoubia",
					    "Médina de Fès",
					    "Kasbah des Oudayas",
					    "Chellah",
					    "Médina de Marrakech"
					)
					
					# 1. Boucle for simple
					print("=== Boucle for simple ===")
					for monument in monuments_maroc:
					    print(f"- {monument}")
					
					# 2. Boucle avec enumerate() pour avoir l'index
					print(f"\n=== Boucle avec enumerate() ===")
					for index, monument in enumerate(monuments_maroc):
					    print(f"{index + 1}. {monument}")
					
					# 3. Boucle avec enumerate() et début personnalisé
					print(f"\n=== Enumerate avec début personnalisé ===")
					for index, monument in enumerate(monuments_maroc, start=1):
					    print(f"Monument #{index}: {monument}")
					
					# 4. Boucle avec range() et accès par index
					print(f"\n=== Boucle avec range() ===")
					for i in range(len(monuments_maroc)):
					    print(f"Position {i}: {monuments_maroc[i]}")
					
					# 5. Boucle while avec index
					print(f"\n=== Boucle while ===")
					index = 0
					while index < len(monuments_maroc):
					    print(f"Monument {index + 1}: {monuments_maroc[index]}")
					    index += 1
					
					# 6. Parcours inversé
					print(f"\n=== Parcours inversé ===")
					for monument in reversed(monuments_maroc):
					    print(f"- {monument}")
					
					# 7. Parcours avec condition
					print(f"\n=== Parcours avec condition ===")
					print("Monuments contenant 'Médina':")
					for monument in monuments_maroc:
					    if "Médina" in monument:
					        print(f"- {monument}")
					
					# 8. Parcours de tuple imbriqué
					print(f"\n=== Parcours de tuple imbriqué ===")
					villes_et_monuments = (
					    ("Casablanca", "Mosquée Hassan II"),
					    ("Marrakech", "Koutoubia"),
					    ("Fès", "Médina de Fès"),
					    ("Rabat", "Kasbah des Oudayas")
					)
					
					for ville, monument in villes_et_monuments:
					    print(f"À {ville}, visitez: {monument}")
					
					# 9. Utilisation avec zip() pour parcourir plusieurs tuples
					print(f"\n=== Parcours avec zip() ===")
					villes = ("Casablanca", "Rabat", "Marrakech")
					populations = (3359000, 577827, 928850)
					regions = ("Casablanca-Settat", "Rabat-Salé-Kénitra", "Marrakech-Safi")
					
					print("Démographie des villes:")
					for ville, population, region in zip(villes, populations, regions):
					    print(f"- {ville} ({region}): {population:,} habitants".replace(",", " "))
					
					# 10. Parcours avec comprehension pour transformation
					print(f"\n=== Transformation avec comprehension ===")
					monuments_majuscules = tuple(monument.upper() for monument in monuments_maroc)
					print(f"Monuments en majuscules: {monuments_majuscules}")
					
					# 11. Utilisation dans une fonction
					def afficher_infos_ville(infos_ville):
					    """Affiche les informations détaillées d'une ville"""
					    nom, population, altitude, capitale = infos_ville
					    statut = "Capitale régionale" if capitale else "Ville"
					    print(f"{statut} {nom}: {population:,} habitants, {altitude}m d'altitude".replace(",", " "))
					
					print(f"\n=== Utilisation dans une fonction ===")
					info_rabat = ("Rabat", 577827, 135, True)
					info_marrakech = ("Marrakech", 928850, 468, True)
					afficher_infos_ville(info_rabat)
					afficher_infos_ville(info_marrakech)

Immutabilité des tuples

L'immuabilité est la caractéristique fondamentale des tuples qui les distingue des listes. Une fois créé, un tuple ne peut pas être modifié, ce qui garantit l'intégrité des données et offre des avantages en termes de performance et de sécurité.

Pourquoi un tuple est immuable

L'immuabilité des tuples répond à des besoins spécifiques en programmation : sécurité des données, hachage pour les clés de dictionnaire, et optimisation mémoire. Cette caractéristique permet d'utiliser les tuples dans des contextes où la stabilité des données est cruciale.

pourquoi_immuable.py
# Démonstration de l'immuabilité des tuples
					
					# 1. Sécurité des données constantes
					# Informations géographiques fixes du Maroc
					infos_maroc_constantes = ("Maroc", "Rabat", "MAD", "+212")
					# pays, capitale, devise, indicatif
					
					print("Informations constantes sur le Maroc:")
					print(infos_maroc_constantes)
					
					# Tentative de modification (échouera)
					print(f"\nTentative de modification de la capitale...")
					try:
					    infos_maroc_constantes[1] = "Casablanca"  # TypeError
					except TypeError as e:
					print(f"Erreur: {e}")
					
					# 2. Hachage pour les clés de dictionnaire
					print(f"\n--- Utilisation comme clés de dictionnaire ---")
					
					# Coordonnées géographiques comme clés
					coordonnees_casa = (33.5731, -7.5898)
					coordonnees_rabat = (34.0209, -6.8416)
					
					villes_par_coordonnees = {
					    coordonnees_casa: "Casablanca",
					    coordonnees_rabat: "Rabat"
					}
					
					print(f"Dictionnaire avec tuples comme clés: {villes_par_coordonnees}")
					print(f"Ville aux coordonnées {coordonnees_casa}: {villes_par_coordonnees[coordonnees_casa]}")
					
					# Vérification du hachage
					print(f"\nHachage des tuples:")
					print(f"Hash de coordonnees_casa: {hash(coordonnees_casa)}")
					print(f"Hash de coordonnees_rabat: {hash(coordonnees_rabat)}")
					
					# 3. Performance et optimisation
					print(f"\n--- Performance ---")
					import sys
					import timeit
					
					villes_liste = ["Casablanca", "Rabat", "Marrakech", "Fès"]
					villes_tuple = ("Casablanca", "Rabat", "Marrakech", "Fès")
					
					print(f"Taille mémoire - Liste: {sys.getsizeof(villes_liste)} octets")
					print(f"Taille mémoire - Tuple: {sys.getsizeof(villes_tuple)} octets")
					
					# 4. Garantie d'intégrité dans les fonctions
					print(f"\n--- Intégrité des données ---")
					
					def traiter_donnees_geographiques(donnees):
					    """Traite des données géographiques sans risque de modification accidentelle"""
					    # Avec un tuple, on est sûr que les données n'ont pas changé
					    ville, population, region = donnees
					    return f"{ville} ({region}) - Population: {population} habitants"
					
					donnees_fixes = ("Agadir", 421844, "Souss-Massa")
					print(traiter_donnees_geographiques(donnees_fixes))
					
					# 5. Utilisation dans les configurations
					print(f"\n--- Configurations système ---")
					
					class SystemeReservation:
					    # Configuration immuable
					    CONFIG_PAR_DEFAUT = (
					        30,      # jours_max_reservation
					        2,       # reservations_simultanees
					        "MAD",   # devise
					        True     # confirmation_obligatoire
					    )
					    
					    def __init__(self):
					        self.jours_max, self.reservations_max, self.devise, self.confirmation = self.CONFIG_PAR_DEFAUT
					    
					    def afficher_config(self):
					        print(f"Configuration: {self.jours_max} jours max, {self.reservations_max} réservations max")
					
					reservation_system = SystemeReservation()
					reservation_system.afficher_config()
					print(f"Config originale protégée: {SystemeReservation.CONFIG_PAR_DEFAUT}")

Conséquences sur la modification et la suppression

L'immuabilité des tuples a des implications directes sur les opérations de modification et de suppression. Contrairement aux listes, on ne peut pas modifier, ajouter ou supprimer des éléments d'un tuple existant.

consequences_immuabilite.py
# Conséquences de l'immuabilité sur les opérations
					
					# Tuple des villes impériales du Maroc
					villes_imperiales = ("Marrakech", "Fès", "Meknès", "Rabat")
					print(f"Tuple original: {villes_imperiales}")
					
					# 1. IMPOSSIBLE: Modification directe d'un élément
					print(f"\n--- Tentatives de modification ---")
					try:
					    villes_imperiales[0] = "Marrakech Ville"  # Échouera
					except TypeError as e:
					print(f"Modification directe: {e}")
					
					# 2. IMPOSSIBLE: Ajout d'éléments
					try:
					    villes_imperiales.append("Casablanca")  # Échouera
					except AttributeError as e:
					print(f"Ajout d'élément: {e}")
					
					# 3. IMPOSSIBLE: Suppression d'éléments
					try:
					    del villes_imperiales[1]  # Échouera
					except TypeError as e:
					print(f"Suppression d'élément: {e}")
					
					# 4. IMPOSSIBLE: Méthodes de modification
					try:
					    villes_imperiales.insert(1, "Tanger")  # Échouera
					except AttributeError as e:
					print(f"Insertion: {e}")
					
					try:
					    villes_imperiales.remove("Fès")  # Échouera
					except AttributeError as e:
					print(f"Suppression par valeur: {e}")
					
					try:
					    villes_imperiales.pop()  # Échouera
					except AttributeError as e:
					print(f"Pop: {e}")
					
					try:
					    villes_imperiales.sort()  # Échouera
					except AttributeError as e:
					print(f"Tri: {e}")
					
					# 5. POSSIBLE: Réaffectation complète
					print(f"\n--- Réaffectation complète ---")
					print(f"Avant réaffectation: {villes_imperiales}")
					print(f"ID avant: {id(villes_imperiales)}")
					
					# On peut réaffecter la variable à un nouveau tuple
					villes_imperiales = ("Marrakech", "Fès", "Meknès", "Rabat", "Casablanca")
					print(f"Après réaffectation: {villes_imperiales}")
					print(f"ID après: {id(villes_imperiales)}")
					print(f"⚠️ Attention: Ce n'est pas une modification, c'est une nouvelle affectation!")
					
					# 6. POSSIBLE: Suppression complète du tuple
					print(f"\n--- Suppression complète ---")
					temp_tuple = ("Tanger", "Tétouan")
					print(f"Avant suppression: {temp_tuple}")
					del temp_tuple
					try:
					    print(temp_tuple)  # NameError
					except NameError:
					print("Tuple supprimé avec succès")
					
					# 7. Comparaison avec les listes
					print(f"\n--- Comparaison tuple vs liste ---")
					
					liste_villes = ["Marrakech", "Fès", "Meknès"]
					tuple_villes = ("Marrakech", "Fès", "Meknès")
					
					print(f"Liste originale: {liste_villes}")
					print(f"Tuple original: {tuple_villes}")
					
					# Liste: modifiable
					liste_villes[0] = "Marrakech Ville"
					liste_villes.append("Rabat")
					print(f"Liste modifiée: {liste_villes}")
					
					# Tuple: erreur si tentative de modification
					try:
					    tuple_villes[0] = "Marrakech Ville"
					except TypeError:
					print(f"Tuple inchangé: {tuple_villes}")
					
					# 8. Impact sur les fonctions
					print(f"\n--- Impact sur le passage aux fonctions ---")
					
					def modifier_donnees(data):
					    """Tente de modifier les données reçues"""
					    print(f"Données reçues: {data}")
					    try:
					        data[0] = "MODIFIÉ"
					        print(f"Modification réussie: {data}")
					    except (TypeError, AttributeError):
					        print("Impossible de modifier - données immuables")
					    return data
					
					liste_test = ["Original", "Données"]
					tuple_test = ("Original", "Données")
					
					print("Avec liste:")
					resultat_liste = modifier_donnees(liste_test)
					print(f"Liste originale après fonction: {liste_test}")
					
					print("\nAvec tuple:")
					resultat_tuple = modifier_donnees(tuple_test)
					print(f"Tuple original après fonction: {tuple_test}")

Modifier indirectement un tuple

Bien que les tuples soient immuables, il existe des techniques pour obtenir des versions modifiées d'un tuple. Ces méthodes créent de nouveaux tuples plutôt que de modifier l'original.

modification_indirecte.py
# Techniques pour modifier indirectement un tuple
					
					# Tuple original des villes marocaines
					villes_original = ("Casablanca", "Rabat", "Marrakech")
					print(f"Tuple original: {villes_original}")
					print(f"ID original: {id(villes_original)}")
					
					# 1. Conversion en liste, modification, reconversion en tuple
					print(f"\n--- Méthode liste/tuple ---")
					liste_temp = list(villes_original)
					liste_temp.append("Fès")  # Ajout
					liste_temp[0] = "Casablanca Ville"  # Modification
					villes_modifie = tuple(liste_temp)
					print(f"Tuple modifié: {villes_modifie}")
					print(f"ID modifié: {id(villes_modifie)}")
					print(f"Même objet? {villes_original is villes_modifie}")
					
					# 2. Concaténation pour ajouter des éléments
					print(f"\n--- Méthode concaténation ---")
					nouvelle_ville = ("Tanger",)
					villes_avec_tanger = villes_original + nouvelle_ville
					print(f"Ajout par concaténation: {villes_avec_tanger}")
					
					# Ajout de plusieurs villes
					villes_supplementaires = ("Agadir", "Oujda")
					villes_etendues = villes_original + villes_supplementaires
					print(f"Plusieurs ajouts: {villes_etendues}")
					
					# 3. Slicing pour "supprimer" des éléments
					print(f"\n--- Méthode slicing ---")
					# "Supprimer" le premier élément
					sans_premier = villes_original[1:]
					print(f"Sans premier élément: {sans_premier}")
					
					# "Supprimer" le dernier élément
					sans_dernier = villes_original[:-1]
					print(f"Sans dernier élément: {sans_dernier}")
					
					# "Supprimer" un élément au milieu
					index_a_supprimer = 1
					sans_milieu = villes_original[:index_a_supprimer] + villes_original[index_a_supprimer+1:]
					print(f"Sans élément à l'index {index_a_supprimer}: {sans_milieu}")
					
					# 4. Remplacement d'éléments par slicing
					print(f"\n--- Remplacement par slicing ---")
					index_a_remplacer = 1
					nouvelle_valeur = ("Rabat Capitale",)
					villes_remplace = villes_original[:index_a_remplacer] + nouvelle_valeur + villes_original[index_a_remplacer+1:]
					print(f"Après remplacement: {villes_remplace}")
					
					# 5. Utilisation de tuples imbriqués modifiables
					print(f"\n--- Tuples avec éléments modifiables ---")
					
					# Tuple contenant une liste (la liste reste modifiable)
					config_systeme = (
					    "Serveur Principal",
					    "192.168.1.1",
					    ["admin", "utilisateur"]  # Liste modifiable
					)
					
					print(f"Config originale: {config_systeme}")
					
					# On peut modifier la liste à l'intérieur du tuple
					config_systeme[2].append("invité")
					config_systeme[2][0] = "administrateur"
					print(f"Config modifiée: {config_systeme}")
					
					# 6. Fonction utilitaire pour les modifications complexes
					print(f"\n--- Fonctions utilitaires ---")
					
					def modifier_tuple(tuple_original, **modifications):
					    """Crée un nouveau tuple avec les modifications spécifiées"""
					    liste_temp = list(tuple_original)
					    
					    for index, valeur in modifications.items():
					        liste_temp[int(index)] = valeur
					    
					    return tuple(liste_temp)
					
					# Exemple d'utilisation
					infos_ville = ("Marrakech", 928850, "Marrakech-Safi")
					print(f"Avant modification: {infos_ville}")
					
					# Modifier la population et la région
					infos_modifiees = modifier_tuple(infos_ville, 1=1000000, 2="Région Marrakech")
					print(f"Après modification: {infos_modifiees}")
					
					# 7. Cas pratique: Gestion d'inventaire
					print(f"\n--- Cas pratique: Inventaire ---")
					
					class InventaireProduits:
					    def __init__(self):
					        # Tuple immuable pour les produits de base
					        self.produits_base = (
					            ("ARG001", "Huile d'Argan", 150.0),
					            ("THE001", "Thé Marocain", 45.0),
					            ("TAP001", "Tapis Berbère", 1200.0)
					        )
					    
					    def ajouter_produit(self, code, nom, prix):
					        "Ajoute un produit en créant un nouveau tuple"
					        nouveau_produit = (code, nom, prix)
					        self.produits_base = self.produits_base + (nouveau_produit,)
					    
					    def afficher_produits(self):
					        print("Produits dans l'inventaire:")
					        for produit in self.produits_base:
					            print(f"  - {produit[1]} ({produit[0]}): {produit[2]} DH")
					
					inventaire = InventaireProduits()
					inventaire.afficher_produits()
					
					print(f"\nAjout d'un nouveau produit...")
					inventaire.ajouter_produit("CER001", "Céramique de Fès", 350.0)
					inventaire.afficher_produits()
					
					print(f"\nID du tuple produits: {id(inventaire.produits_base)}")

Opérations et fonctions utiles

Python offre diverses opérations et fonctions intégrées pour travailler efficacement avec les tuples. Ces outils permettent de combiner, rechercher et analyser les données contenues dans les tuples de manière optimale.

Concaténation et répétition de tuples

La concaténation permet de combiner plusieurs tuples en un seul, tandis que la répétition permet de créer un nouveau tuple en dupliquant le contenu d'un tuple existant. Ces opérations créent toujours de nouveaux tuples sans modifier les originaux.

concatenation_repetition.py
# Opérations de concaténation et répétition sur les tuples
					
					# 1. Concaténation de base avec l'opérateur +
					villes_nord = ("Tanger", "Tétouan", "Chefchaouen")
					villes_sud = ("Agadir", "Dakhla", "Laayoune")
					villes_imperiales = ("Marrakech", "Fès", "Meknès")
					
					# Concaténation simple
					toutes_villes = villes_nord + villes_sud
					print(f"Villes du Nord + Sud: {toutes_villes}")
					
					# Concaténation multiple
					villes_completes = villes_nord + villes_imperiales + villes_sud
					print(f"Toutes les villes: {villes_completes}")
					
					# 2. Concaténation avec des tuples à un élément
					print(f"\n--- Concaténation avec tuples unitaires ---")
					capitale = ("Rabat",)
					villes_avec_capitale = villes_nord + capitale + villes_sud
					print(f"Avec capitale: {villes_avec_capitale}")
					
					# 3. Concaténation avec assignment
					print(f"\n--- Concaténation avec réaffectation ---")
					villes_actuelles = ("Casablanca", "Rabat")
					print(f"Avant: {villes_actuelles}")
					print(f"ID avant: {id(villes_actuelles)}")
					
					villes_actuelles = villes_actuelles + ("Marrakech", "Fès")
					print(f"Après: {villes_actuelles}")
					print(f"ID après: {id(villes_actuelles)}")
					print(f"⚠️ Nouveau tuple créé!")
					
					# 4. Répétition avec l'opérateur *
					print(f"\n--- Répétition de tuples ---")
					ville_unique = ("Casablanca",)
					villes_repetees = ville_unique * 5
					print(f"Répétition 5 fois: {villes_repetees}")
					
					regions_principales = ("Casablanca-Settat", "Rabat-Salé-Kénitra")
					regions_etendues = regions_principales * 3
					print(f"Régions répétées 3 fois: {regions_etendues}")
					
					# 5. Combinaison concaténation + répétition
					print(f"\n--- Combinaison d'opérations ---")
					villes_cotieres = ("Tanger", "Casablanca", "Agadir")
					separateur = ("---",)
					liste_presentation = (villes_cotieres + separateur) * 2
					print(f"Liste de présentation: {liste_presentation}")
					
					# 6. Cas pratique: Génération de configurations
					print(f"\n--- Cas pratique: Configuration système ---")
					
					class SystemeReservation:
					    JOURS_SEMAINE = ("Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi")
					    
					    def generer_calendrier_semaine(self, semaines=4):
					        "Génère un calendrier pour plusieurs semaines"
					        semaine_complete = self.JOURS_SEMAINE + ("Samedi", "Dimanche")
					        calendrier = semaine_complete * semaines
					        return calendrier
					    
					    def creer_creneaux_repetitifs(self, creneau_base, repetitions):
					        "Crée des créneaux répétitifs"
					        return creneau_base * repetitions
					
					reservation = SystemeReservation()
					calendrier_mois = reservation.generer_calendrier_semaine(4)
					print(f"Calendrier sur 4 semaines: {calendrier_mois}")
					print(f"Nombre de jours: {len(calendrier_mois)}")
					
					creneau_horaire = ("09:00-10:30",)
					creneaux_jour = reservation.creer_creneaux_repetitifs(creneau_horaire, 8)
					print(f"Créneaux horaires: {creneaux_jour}")
					
					# 7. Performance de la concaténation
					print(f"\n--- Performance et bonnes pratiques ---")
					
					# Méthode efficace pour de multiples concaténations
					tous_tuples = [
					    ("Maroc",),
					    ("Algérie",),
					    ("Tunisie",),
					    ("Égypte",)
					]
					
					# Méthode inefficace (création multiple de tuples)
					pays_afrique = ()
					for pays in tous_tuples:
					    pays_afrique = pays_afrique + pays  # Crée un nouveau tuple à chaque itération
					print(f"Pays (méthode lente): {pays_afrique}")
					
					# Méthode efficace (une seule concaténation)
					pays_afrique_opti = tuple()
					for pays in tous_tuples:
					    pays_afrique_opti += pays  # Plus optimisé en interne
					print(f"Pays (méthode optimisée): {pays_afrique_opti}")
					
					# 8. Vérification de l'immuabilité
					print(f"\n--- Vérification d'immuabilité ---")
					original = (1, 2, 3)
					concatene = original + (4, 5)
					print(f"Original: {original}, ID: {id(original)}")
					print(f"Concaténé: {concatene}, ID: {id(concatene)}")
					print(f"Original inchangé: {original}")

Vérifier la présence d'un élément (in)

L'opérateur in permet de vérifier rapidement si un élément est présent dans un tuple. Cette opération est très efficace et largement utilisée pour les tests de présence et les validations.

verification_presence.py
# Vérification de présence d'éléments dans les tuples
					
					# 1. Vérification basique avec 'in'
					villes_maroc = ("Casablanca", "Rabat", "Marrakech", "Fès", "Tanger")
					
					print("--- Tests de présence basiques ---")
					print(f"Villes disponibles: {villes_maroc}")
					print(f"'Casablanca' dans le tuple? {'Casablanca' in villes_maroc}")
					print(f"'Agadir' dans le tuple? {'Agadir' in villes_maroc}")
					print(f"'rabat' dans le tuple? {'rabat' in villes_maroc}")  # Sensible à la casse
					
					# 2. Vérification avec 'not in'
					print(f"\n--- Tests d'absence ---")
					print(f"'Dakhla' pas dans le tuple? {'Dakhla' not in villes_maroc}")
					print(f"'Rabat' pas dans le tuple? {'Rabat' not in villes_maroc}")
					
					# 3. Utilisation dans des conditions
					print(f"\n--- Utilisation dans les conditions ---")
					
					def verifier_ville_imperiale(ville):
					    villes_imperiales = ("Marrakech", "Fès", "Meknès", "Rabat")
					    
					    if ville in villes_imperiales:
					        return f"{ville} est une ville impériale du Maroc"
					    else:
					        return f"{ville} n'est pas une ville impériale"
					
					print(verifier_ville_imperiale("Marrakech"))
					print(verifier_ville_imperiale("Casablanca"))
					
					# 4. Recherche dans des tuples imbriqués
					print(f"\n--- Recherche dans tuples imbriqués ---")
					
					regions_villes = (
					    ("Casablanca-Settat", "Casablanca", "Settat"),
					    ("Rabat-Salé-Kénitra", "Rabat", "Salé", "Kénitra"),
					    ("Marrakech-Safi", "Marrakech", "Safi")
					)
					
					print(f"'Casablanca' dans les régions? {any('Casablanca' in region for region in regions_villes)}")
					print(f"'Agadir' dans les régions? {any('Agadir' in region for region in regions_villes)}")
					
					# 5. Recherche avec plusieurs conditions
					print(f"\n--- Recherche avec conditions multiples ---")
					
					class SystemeReservationVol:
					    VILLES_DESSERVIES = ("Casablanca", "Marrakech", "Agadir", "Tanger", "Fès")
					    
					    def verifier_destination(self, ville_depart, ville_arrivee):
					        if ville_depart not in self.VILLES_DESSERVIES:
					            return f"Erreur: Départ de {ville_depart} non disponible"
					        
					        if ville_arrivee not in self.VILLES_DESSERVIES:
					            return f"Erreur: Arrivée à {ville_arrivee} non disponible"
					        
					        if ville_depart == ville_arrivee:
					            return "Erreur: Ville de départ et d'arrivée identiques"
					        
					        return f"Vol confirmé: {ville_depart} → {ville_arrivee}"
					
					reservation_vol = SystemeReservationVol()
					print(reservation_vol.verifier_destination("Casablanca", "Marrakech"))
					print(reservation_vol.verifier_destination("Casablanca", "Paris"))
					print(reservation_vol.verifier_destination("Rabat", "Marrakech"))
					
					# 6. Performance de la recherche
					print(f"\n--- Performance de la recherche ---")
					
					import time
					
					# Création d'un grand tuple
					grand_tuple = tuple(range(1000000))  # 1 million d'éléments
					
					# Recherche d'un élément au début
					debut = time.time()
					trouve_debut = 10 in grand_tuple
					temps_debut = time.time() - debut
					
					# Recherche d'un élément à la fin
					debut = time.time()
					trouve_fin = 999999 in grand_tuple
					temps_fin = time.time() - debut
					
					# Recherche d'un élément absent
					debut = time.time()
					trouve_absent = -1 in grand_tuple
					temps_absent = time.time() - debut
					
					print(f"Recherche au début: {temps_debut:.6f} secondes")
					print(f"Recherche à la fin: {temps_fin:.6f} secondes")
					print(f"Recherche absent: {temps_absent:.6f} secondes")
					print(f"⚠️ La recherche dans les tuples est séquentielle (O(n))")
					
					# 7. Cas pratique: Système d'authentification
					print(f"\n--- Cas pratique: Authentification ---")
					
					class SystemeAuthentification:
					    # Utilisateurs autorisés (tuple pour immutabilité)
					    UTILISATEURS_AUTORISES = (
					        ("admin", "admin123"),
					        ("karim", "pass123"),
					        ("fatima", "secret456")
					    )
					    
					    def authentifier(self, username, password):
					        credentials = (username, password)
					        return credentials in self.UTILISATEURS_AUTORISES
					
					auth = SystemeAuthentification()
					print(f"Authentification admin: {auth.authentifier('admin', 'admin123')}")
					print(f"Authentification invalide: {auth.authentifier('admin', 'wrongpass')}")
					print(f"Authentification karim: {auth.authentifier('karim', 'pass123')}")

Fonctions intégrées (len(), min(), max(), sum())

Python fournit plusieurs fonctions intégrées qui fonctionnent avec les tuples pour obtenir des informations statistiques et mesurer leurs caractéristiques. Ces fonctions sont optimisées et très efficaces.

fonctions_integres.py
# Fonctions intégrées pour l'analyse des tuples
					
					# 1. len() - Longueur d'un tuple
					print("--- Fonction len() ---")
					
					villes_maroc = ("Casablanca", "Rabat", "Marrakech", "Fès", "Tanger", "Agadir")
					populations = (3359000, 577827, 928850, 1112072, 947952, 421844)
					
					print(f"Nombre de villes: {len(villes_maroc)}")
					print(f"Nombre de populations: {len(populations)}")
					print(f"Tuple vide: {len(())}")
					print(f"Tuple à un élément: {len(('Rabat',))}")
					
					# 2. min() et max() - Valeurs extrêmes
					print(f"\n--- Fonctions min() et max() ---")
					
					temperatures = (32, 28, 35, 40, 25, 38)
					altitudes = (12, 135, 468, 410, 580, 23)
					
					print(f"Températures: {temperatures}")
					print(f"Température minimale: {min(temperatures)}°C")
					print(f"Température maximale: {max(temperatures)}°C")
					print(f"Altitude minimale: {min(altitudes)}m")
					print(f"Altitude maximale: {max(altitudes)}m")
					
					# min() et max() avec des chaînes
					print(f"\nVilles: {villes_maroc}")
					print(f"Ville première alphabétiquement: {min(villes_maroc)}")
					print(f"Ville dernière alphabétiquement: {max(villes_maroc)}")
					
					# 3. sum() - Somme des éléments
					print(f"\n--- Fonction sum() ---")
					
					print(f"Populations: {populations}")
					print(f"Population totale: {sum(populations):,} habitants".replace(",", " "))
					print(f"Somme des températures: {sum(temperatures)}")
					print(f"Moyenne des températures: {sum(temperatures) / len(temperatures):.1f}°C")
					
					# 4. Combinaison de fonctions
					print(f"\n--- Combinaison de fonctions ---")
					
					def analyser_donnees(donnees):
					    "Analyse complète d'un tuple de données numériques"
					    if not donnees:
					        return "Aucune donnée à analyser"
					    
					    minimum = min(donnees)
					    maximum = max(donnees)
					    total = sum(donnees)
					    moyenne = total / len(donnees)
					    etendue = maximum - minimum
					    
					    return {
					        "min": minimum,
					        "max": maximum,
					        "total": total,
					        "moyenne": moyenne,
					        "étendue": etendue,
					        "nombre": len(donnees)
					    }
					
					revenus_trimestriels = (1250000, 980000, 1560000, 1420000)
					analyse = analyser_donnees(revenus_trimestriels)
					print(f"Revenus trimestriels: {revenus_trimestriels}")
					for cle, valeur in analyse.items():
					    print(f"  {cle}: {valeur:,.0f} DH".replace(",", " "))
					
					# 5. Gestion des erreurs
					print(f"\n--- Gestion des erreurs ---")
					
					# Tuple vide
					try:
					    print(min(()))
					except ValueError as e:
					print(f"Erreur min() sur tuple vide: {e}")
					
					try:
					    print(max(()))
					except ValueError as e:
					print(f"Erreur max() sur tuple vide: {e}")
					
					print(f"Somme tuple vide: {sum(())}")  # Retourne 0
					print(f"Longueur tuple vide: {len(())}")  # Retourne 0
					
					# Types incompatibles
					mixte = (1, "deux", 3.0)
					try:
					    print(min(mixte))
					except TypeError as e:
					print(f"Erreur types incompatibles: {e}")
					
					# 6. Cas pratique: Système de statistiques
					print(f"\n--- Cas pratique: Statistiques touristiques ---")
					
					class StatistiquesTourisme:
					    def __init__(self):
					        self.visiteurs_mensuels = ()
					    
					    def ajouter_mois(self, visiteurs):
					        self.visiteurs_mensuels += (visiteurs,)
					    
					    def generer_rapport(self):
					        if not self.visiteurs_mensuels:
					            return "Aucune donnée disponible"
					        
					        total_visiteurs = sum(self.visiteurs_mensuels)
					        moyenne_mensuelle = total_visiteurs / len(self.visiteurs_mensuels)
					        mois_plus_visite = max(self.visiteurs_mensuels)
					        mois_moins_visite = min(self.visiteurs_mensuels)
					        
					        return (
					            f"Rapport sur {len(self.visiteurs_mensuels)} mois:\n"
					            f"  Total visiteurs: {total_visiteurs:,}\n".replace(",", " ") +
					            f"  Moyenne mensuelle: {moyenne_mensuelle:,.0f}\n".replace(",", " ") +
					            f"  Meilleur mois: {mois_plus_visite:,} visiteurs\n".replace(",", " ") +
					            f"  Mois le plus calme: {mois_moins_visite:,} visiteurs".replace(",", " ")
					        )
					
					stats = StatistiquesTourisme()
					stats.ajouter_mois(125000)
					stats.ajouter_mois(98000)
					stats.ajouter_mois(156000)
					stats.ajouter_mois(142000)
					stats.ajouter_mois(110000)
					
					print(stats.generer_rapport())
					
					# 7. Performance des fonctions intégrées
					print(f"\n--- Performance ---")
					
					import time
					
					# Grand tuple de données
					grandes_donnees = tuple(range(1, 1000001))  # 1 million de nombres
					
					debut = time.time()
					longueur = len(grandes_donnees)
					temps_len = time.time() - debut
					
					debut = time.time()
					minimum = min(grandes_donnees)
					temps_min = time.time() - debut
					
					debut = time.time()
					maximum = max(grandes_donnees)
					temps_max = time.time() - debut
					
					debut = time.time()
					somme = sum(grandes_donnees)
					temps_sum = time.time() - debut
					
					print(f"Performance sur 1 million d'éléments:")
					print(f"  len(): {temps_len:.6f}s")
					print(f"  min(): {temps_min:.6f}s")
					print(f"  max(): {temps_max:.6f}s")
					print(f"  sum(): {temps_sum:.6f}s")
					print(f"  Résultats - Longueur: {longueur}, Min: {minimum}, Max: {maximum}, Somme: {somme:,}".replace(",", " "))

Déballage (unpacking) des tuples

Le déballage (unpacking) est une fonctionnalité puissante de Python qui permet d'assigner les éléments d'un tuple à des variables individuelles en une seule opération. Cette technique rend le code plus lisible et concis.

Affectation multiple

L'affectation multiple permet d'assigner les éléments d'un tuple à plusieurs variables en une seule ligne. C'est l'une des utilisations les plus courantes et pratiques du déballage des tuples.

affectation_multiple.py
# Affectation multiple avec déballage de tuples
					
					# 1. Déballage basique
					print("--- Déballage basique ---")
					
					coordonnees_marrakech = (31.6295, -7.9811)
					latitude, longitude = coordonnees_marrakech
					print(f"Coordonnées de Marrakech: latitude={latitude}, longitude={longitude}")
					
					# 2. Déballage avec informations ville
					infos_casablanca = ("Casablanca", 3359000, "Casablanca-Settat")
					nom, population, region = infos_casablanca
					print(f"\n{nom} - Population: {population:,} - Région: {region}".replace(",", " "))
					
					# 3. Échange de valeurs sans variable temporaire
					print(f"\n--- Échange de valeurs ---")
					
					ville_a, ville_b = "Rabat", "Casablanca"
					print(f"Avant échange: ville_a={ville_a}, ville_b={ville_b}")
					
					# Échange élégant avec tuple unpacking
					ville_a, ville_b = ville_b, ville_a
					print(f"Après échange: ville_a={ville_a}, ville_b={ville_b}")
					
					# 4. Déballage depuis le retour d'une fonction
					print(f"\n--- Déballage depuis fonction ---")
					
					def obtenir_infos_ville(ville):
					    "Retourne les informations d'une ville sous forme de tuple"
					    infos = {
					        "Rabat": ("Rabat", 577827, "Capitale", 135),
					        "Marrakech": ("Marrakech", 928850, "Ville Impériale", 468),
					        "Fès": ("Fès", 1112072, "Ville Impériale", 410)
					    }
					    return infos.get(ville, ("Inconnue", 0, "Inconnue", 0))
					
					# Déballage direct du retour de fonction
					nom_ville, population, type_ville, altitude = obtenir_infos_ville("Marrakech")
					print(f"{nom_ville} - {population} habitants - {type_ville} - Altitude: {altitude}m")
					
					# 5. Déballage dans les boucles
					print(f"\n--- Déballage dans les boucles ---")
					
					villes_infos = [
					    ("Casablanca", 3359000, "Économique"),
					    ("Rabat", 577827, "Politique"),
					    ("Marrakech", 928850, "Touristique")
					]
					
					print("Villes du Maroc:")
					for nom, population, role in villes_infos:
					    print(f"  - {nom}: {population:,} habitants (Rôle: {role})".replace(",", " "))
					
					# 6. Déballage avec des tuples imbriqués
					print(f"\n--- Déballage de tuples imbriqués ---")
					
					ville_complete = ("Fès", 1112072, (34.0333, -5.0000))
					nom_ville, population, (lat, lon) = ville_complete
					print(f"{nom_ville} - Population: {population} - GPS: ({lat}, {lon})")
					
					# 7. Cas pratique: Système de coordonnées
					print(f"\n--- Cas pratique: Gestion de coordonnées ---")
					
					class SystemeGeographique:
					    def __init__(self):
					        self.villes = {
					            "Casablanca": (33.5731, -7.5898, "Côte Atlantique"),
					            "Marrakech": (31.6295, -7.9811, "Plaine du Haouz"),
					            "Fès": (34.0333, -5.0000, "Plateau du Saïss")
					        }
					    
					    def afficher_localisation(self, ville):
					        if ville in self.villes:
					            latitude, longitude, region = self.villes[ville]
					            print(f"{ville} - Région: {region}")
					            print(f"  Coordonnées: {latitude}°N, {longitude}°W")
					        else:
					            print(f"Ville {ville} non trouvée")
					
					geo = SystemeGeographique()
					geo.afficher_localisation("Marrakech")
					geo.afficher_localisation("Casablanca")
					
					# 8. Gestion des erreurs
					print(f"\n--- Gestion des erreurs de déballage ---")
					
					# Erreur: trop de valeurs à déballer
					try:
					    a, b = (1, 2, 3)
					except ValueError as e:
					print(f"Erreur de déballage: {e}")
					
					# Erreur: pas assez de valeurs
					try:
					    x, y, z = (10, 20)
					except ValueError as e:
					print(f"Erreur de déballage: {e}")
					
					# Vérification avant déballage
					donnees = ("Rabat", 577827)
					if len(donnees) == 3:
					    ville, pop, region = donnees
					else:
					    print("Structure de données invalide pour le déballage")

Ignorer certaines valeurs

Il est souvent utile d'ignorer certaines valeurs lors du déballage. Python permet cela en utilisant le caractère underscore _ comme variable "poubelle" pour les valeurs non souhaitées.

ignorer_valeurs.py
# Ignorer des valeurs lors du déballage de tuples
					
					# 1. Utilisation de _ pour ignorer des valeurs
					print("--- Ignorer avec _ ---")
					
					# Tuple avec plusieurs informations
					infos_vol = ("CMN", "RAK", "AT800", "2024-01-15", "10:30", "12:00")
					# aéroport_départ, aéroport_arrivée, numéro_vol, date, heure_départ, heure_arrivée
					
					# On ne veut que les aéroports et la date
					depart, arrivee, _, date, _, _ = infos_vol
					print(f"Vol de {depart} à {arrivee} le {date}")
					
					# 2. Ignorer plusieurs valeurs consécutives
					print(f"\n--- Ignorer plusieurs valeurs ---")
					
					donnees_capteur = (25.5, 65.2, 1013.2, 2.1, 45.6, "OK")
					# température, humidité, pression, vitesse_vent, radiation, statut
					
					# Seulement température et statut
					temperature, *_, statut = donnees_capteur
					print(f"Température: {temperature}°C, Statut: {statut}")
					
					# 3. Ignorer des valeurs dans les boucles
					print(f"\n--- Ignorer dans les boucles ---")
					
					resultats_examen = [
					    ("Ahmed", "Math", 16.5, "2024-01-10"),
					    ("Fatima", "Physique", 18.0, "2024-01-11"),
					    ("Karim", "Chimie", 14.5, "2024-01-12")
					]
					
					print("Résultats des étudiants:")
					for nom, _, note, _ in resultats_examen:
					    print(f"  - {nom}: {note}/20")
					
					# 4. Ignorer le premier ou dernier élément
					print(f"\n--- Ignorer premier/dernier ---")
					
					serie_temperatures = (22.1, 23.5, 24.8, 25.3, 24.9, 23.7)
					
					# Ignorer le premier élément (capteur défaillant)
					_, *temperatures_valides = serie_temperatures
					print(f"Températures valides: {temperatures_valides}")
					
					# Ignorer le dernier élément (mesure incomplète)
					*temperatures_completes, _ = serie_temperatures
					print(f"Températures complètes: {temperatures_completes}")
					
					# 5. Cas pratique: Traitement de données météo
					print(f"\n--- Cas pratique: Données météorologiques ---")
					
					class AnalyseMeteo:
					    def __init__(self):
					        self.donnees_brutes = []
					    
					    def ajouter_releve(self, releve):
					        "Ajoute un relevé météo (timestamp, temp, humidité, pression, vent, station)"
					        self.donnees_brutes.append(releve)
					    
					    def extraire_temperatures(self):
					        "Extrait seulement les températures en ignorant les autres données"
					        temperatures = []
					        for timestamp, temperature, *_ in self.donnees_brutes:
					            temperatures.append(temperature)
					        return temperatures
					    
					    def analyser_tendances(self):
					        "Analyse les tendances en ignorant les données de station"
					        if not self.donnees_brutes:
					            return "Aucune donnée"
					        
					        *_, (dernier_ts, derniere_temp, _, _, _, _) = self.donnees_brutes
					        premier_ts, premiere_temp, *_ = self.donnees_brutes[0]
					        
					        evolution = derniere_temp - premiere_temp
					        return f"Évolution: {evolution:+.1f}°C de {premier_ts} à {dernier_ts}"
					
					meteo = AnalyseMeteo()
					meteo.ajouter_releve(("2024-01-15 08:00", 18.5, 65, 1015, 12, "Casablanca"))
					meteo.ajouter_releve(("2024-01-15 12:00", 24.2, 55, 1013, 8, "Casablanca"))
					meteo.ajouter_releve(("2024-01-15 16:00", 22.8, 60, 1014, 15, "Casablanca"))
					
					print(f"Températures: {meteo.extraire_temperatures()}")
					print(meteo.analyser_tendances())
					
					# 6. Ignorer dans les fonctions
					print(f"\n--- Ignorer dans les fonctions ---")
					
					def traiter_commande(donnees_commande):
					    "Traite une commande en ignorant certaines métadonnées"
					    # Format: (id_commande, client, produit, quantite, prix, date, statut_livraison)
					    _, client, produit, quantite, prix, _, _ = donnees_commande
					    total = quantite * prix
					    return f"Commande {client}: {quantite}x {produit} = {total} DH"
					
					commande = (1001, "Restaurant Marrakech", "Huile d'Argan", 5, 150.0, "2024-01-15", "en cours")
					print(traiter_commande(commande))
					
					# 7. Bonnes pratiques
					print(f"\n--- Bonnes pratiques ---")
					
					# Utiliser _ pour les valeurs vraiment ignorées
					ville, _, region = ("Tanger", 947952, "Tanger-Tétouan-Al Hoceïma")
					print(f"{ville} - {region}")
					
					# Éviter d'utiliser _ comme variable normale
					# _ = "valeur temporaire"  # À éviter
					# print(_)  # Risque de confusion
					
					# Utilisation correcte dans les compréhensions
					villes_complexes = [
					    ("Casablanca", 3359000, "économique", 33.5731, -7.5898),
					    ("Marrakech", 928850, "touristique", 31.6295, -7.9811)
					]
					
					# Extraire seulement noms et rôles
					noms_roles = [(nom, role) for nom, _, role, *_ in villes_complexes]
					print(f"Noms et rôles: {noms_roles}")

Utiliser * pour capturer plusieurs éléments

L'opérateur * permet de capturer plusieurs éléments lors du déballage. Cette fonctionnalité est extrêmement utile pour travailler avec des tuples de taille variable ou pour séparer les éléments en groupes.

capture_multiple.py
# Utilisation de * pour capturer plusieurs éléments
					
					# 1. Capture basique avec *
					print("--- Capture basique avec * ---")
					
					villes_maroc = ("Casablanca", "Rabat", "Marrakech", "Fès", "Tanger", "Agadir")
					
					# Première ville et le reste
					premiere, *reste = villes_maroc
					print(f"Première ville: {premiere}")
					print(f"Autres villes: {reste}")
					
					# Première, dernière, et celles du milieu
					premiere, *milieu, derniere = villes_maroc
					print(f"\nPremière: {premiere}, Dernière: {derniere}")
					print(f"Villes du milieu: {milieu}")
					
					# 2. Capture à différentes positions
					print(f"\n--- Capture à différentes positions ---")
					
					donnees_meteo = ("Casablanca", 25.5, 65, 1013, 15, "ensoleillé", "2024-01-15")
					
					# Capture au début
					*meteo, date = donnees_meteo
					print(f"Données météo: {meteo}")
					print(f"Date: {date}")
					
					# Capture au milieu
					ville, temperature, *details, conditions, date = donnees_meteo
					print(f"\nVille: {ville}, Température: {temperature}°C")
					print(f"Détails: {details}")
					print(f"Conditions: {conditions}, Date: {date}")
					
					# 3. Capture dans les boucles
					print(f"\n--- Capture dans les boucles ---")
					
					voyages = [
					    ("Casablanca", "Marrakech", "Fès", "Tanger"),
					    ("Rabat", "Meknès"),
					    ("Agadir", "Essaouira", "Safi"),
					    ("Tanger",)
					]
					
					print("Itinéraires de voyage:")
					for premiere, *autres in voyages:
					    if autres:
					        print(f"  Départ de {premiere}, puis: {', '.join(autres)}")
					    else:
					        print(f"  Séjour à {premiere}")
					
					# 4. Capture multiple avec *
					print(f"\n--- Capture multiple ---")
					
					classements = ("Raja CA", "Wydad AC", "FAR", "MAS", "OCS", "HUSA", "RCA")
					
					# Premier, les 3 suivants, et le reste
					premier, *suivants, *reste = classements  # Erreur: multiple *
					
					# Correct: un seul * par déballage
					premier, deuxieme, troisieme, *reste = classements
					print(f"Podium: 1.{premier}, 2.{deuxieme}, 3.{troisieme}")
					print(f"Autres équipes: {reste}")
					
					# 5. Cas pratique: Système de réservation
					print(f"\n--- Cas pratique: Système de réservation ---")
					
					class GestionnaireReservations:
					    def __init__(self):
					        self.reservations = []
					    
					    def ajouter_reservation(self, *infos_reservation):
					        "Ajoute une réservation (client, *passagers, hotel, dates)"
					        self.reservations.append(infos_reservation)
					    
					    def lister_reservations(self):
					        print("Réservations en cours:")
					        for i, reservation in enumerate(self.reservations, 1):
					            client, *passagers, hotel, dates = reservation
					            print(f"  {i}. Client: {client}")
					            if passagers:
					                print(f"     Passagers: {', '.join(passagers)}")
					            print(f"     Hôtel: {hotel}, Dates: {dates}")
					    
					    def statistiques_passagers(self):
					        "Calcule les statistiques sur les passagers"
					        total_passagers = 0
					        reservations_avec_passagers = 0
					        
					        for reservation in self.reservations:
					            _, *passagers, _, _ = reservation
					            total_passagers += len(passagers)
					            if passagers:
					                reservations_avec_passagers += 1
					        
					        return {
					            "total_passagers": total_passagers,
					            "reservations_avec_passagers": reservations_avec_passagers,
					            "total_reservations": len(self.reservations)
					        }
					
					reservations = GestionnaireReservations()
					reservations.ajouter_reservation("Ahmed Alami", "Fatima Alami", "La Mamounia", "2024-03-15/2024-03-20")
					reservations.ajouter_reservation("Karim Bennani", "Sofia Bennani", "Yasmine Bennani", "Royal Mansour", "2024-04-01/2024-04-07")
					reservations.ajouter_reservation("Leila Cherkaoui", "Hotel Hassan", "2024-02-10/2024-02-12")
					
					reservations.lister_reservations()
					stats = reservations.statistiques_passagers()
					print(f"\nStatistiques: {stats}")
					
					# 6. Capture avec des valeurs par défaut
					print(f"\n--- Capture avec valeurs par défaut ---")
					
					def traiter_commandes(*commandes):
					    "Traite des commandes de longueur variable"
					    print("Commandes à traiter:")
					    for commande in commandes:
					        # Format: (produit, quantite, *options)
					        produit, quantite, *options = commande
					        urgente = "URGENT" if "urgent" in options else "normal"
					        emballage = options[1] if len(options) > 1 else "standard"
					        print(f"  - {produit} x{quantite} ({urgente}, emballage: {emballage})")
					
					commandes_variées = [
					    ("Huile d'Argan", 2),
					    ("Tapis Berbère", 1, "urgent"),
					    ("Thé Marocain", 5, "normal", "cadeau"),
					    ("Poterie de Fès", 3, "urgent", "renforcé")
					]
					
					traiter_commandes(*commandes_variées)
					
					# 7. Capture avancée avec conditions
					print(f"\n--- Capture avancée avec conditions ---")
					
					resultats_concours = [
					    ("Ahmed", 18.5, 16.0, 17.5, 19.0),
					    ("Fatima", 20.0, 19.5, 18.0),
					    ("Karim", 15.5, 16.5, 14.0, 17.0, 16.0),
					    ("Sofia", 19.0, 18.5)
					]
					
					print("Résultats du concours (meilleure et pire note ignorées):")
					for participant, meilleure, *notes_intermediaires, pire in resultats_concours:
					    moyenne_intermediaire = sum(notes_intermediaires) / len(notes_intermediaires) if notes_intermediaires else 0
					    print(f"  {participant}: moyenne intermédiaire = {moyenne_intermediaire:.2f}")
					
					# 8. Combinaison avec d'autres techniques
					print(f"\n--- Combinaison de techniques ---")
					
					donnees_complexes = [
					    ("Casablanca", 3359000, "économique", 33.5731, -7.5898, "port", "mosquée"),
					    ("Marrakech", 928850, "touristique", 31.6295, -7.9811, "place", "jardin", "souk"),
					    ("Fès", 1112072, "culturel", 34.0333, -5.0000)
					]
					
					print("Informations essentielles des villes:")
					for ville, population, type_ville, *_, *attractions in donnees_complexes:
					    attractions_text = ", ".join(attractions) if attractions else "aucune"
					    print(f"  {ville} ({type_ville}): {attractions_text}")

Tuples imbriqués et tuples de tuples

Les tuples peuvent contenir d'autres tuples, créant ainsi des structures de données complexes et hiérarchiques. Cette fonctionnalité est particulièrement utile pour représenter des données multidimensionnelles comme des coordonnées, des matrices ou des structures arborescentes.

Accéder à des éléments dans un tuple imbriqué

L'accès aux éléments dans des tuples imbriqués se fait en chaînant les indices. Chaque niveau d'imbrication nécessite un indice supplémentaire pour atteindre l'élément souhaité.

acces_tuples_imbriques.py
# Accès aux éléments dans des tuples imbriqués
					
					# 1. Structure basique de tuple imbriqué
					print("--- Structure basique ---")
					
					# Coordonnées GPS de villes marocaines
					coordonnees_ville = ((31.6295, -7.9811), "Marrakech", "Marrakech-Safi")
					print(f"Tuple complet: {coordonnees_ville}")
					print(f"Type: {type(coordonnees_ville)}")
					print(f"Coordonnées GPS: {coordonnees_ville[0]}")
					print(f"Type des coordonnées: {type(coordonnees_ville[0])}")
					print(f"Latitude: {coordonnees_ville[0][0]}")
					print(f"Longitude: {coordonnees_ville[0][1]}")
					print(f"Nom de la ville: {coordonnees_ville[1]}")
					print(f"Région: {coordonnees_ville[2]}")
					
					# 2. Tuple de tuples (matrice 2D)
					print(f"\n--- Tuple de tuples (matrice) ---")
					
					# Distances entre villes marocaines (en km)
					distances_villes = (
					    (0, 86, 240, 530, 330),    # De Casablanca
					    (86, 0, 320, 590, 400),     # De Rabat
					    (240, 320, 0, 470, 170),    # De Marrakech
					    (530, 590, 470, 0, 640),     # De Fès
					    (330, 400, 170, 640, 0)      # De Agadir
					)
					
					villes = ["Casablanca", "Rabat", "Marrakech", "Fès", "Agadir"]
					
					print("Matrice des distances:")
					for i in range(len(distances_villes)):
					    for j in range(len(distances_villes[i])):
					        if i != j:
					            print(f"  {villes[i]} → {villes[j]}: {distances_villes[i][j]} km")
					
					# 3. Accès avec déballage multiple
					print(f"\n--- Accès avec déballage ---")
					
					# Informations détaillées sur une ville
					ville_complete = ("Fès", 1112072, (34.0333, -5.0000), ("Médina", "Université Al Quaraouiyine"))
					
					# Déballage multiple
					nom, population, (latitude, longitude), (attraction1, attraction2) = ville_complete
					print(f"Ville: {nom}")
					print(f"Population: {population:,}".replace(",", " "))
					print(f"Coordonnées: ({latitude}, {longitude})")
					print(f"Attractions: {attraction1}, {attraction2}")
					
					# 4. Structure hiérarchique complexe
					print(f"\n--- Structure hiérarchique ---")
					
					# Régions du Maroc avec leurs villes principales
					regions_maroc = (
					    ("Casablanca-Settat", (("Casablanca", 3359000), ("Settat", 142250))),
					    ("Rabat-Salé-Kénitra", (("Rabat", 577827), ("Salé", 890403), ("Kénitra", 431282))),
					    ("Marrakech-Safi", (("Marrakech", 928850), ("Safi", 308508)))
					)
					
					print("Structure régionale du Maroc:")
					for region in regions_maroc:
					    nom_region, villes_region = region
					print(f"\nRégion: {nom_region}")
					for ville, population in villes_region:
					    print(f"  - {ville}: {population:,} habitants".replace(",", " "))
					
					# 5. Accès profond avec indices multiples
					print(f"\n--- Accès profond ---")
					
					print(f"Première région: {regions_maroc[0][0]}")
					print(f"Première ville de la première région: {regions_maroc[0][1][0][0]}")
					print(f"Population de Casablanca: {regions_maroc[0][1][0][1]:,}".replace(",", " "))
					
					# 6. Parcours récursif des tuples imbriqués
					print(f"\n--- Parcours récursif ---")
					
					def parcourir_tuples(structure, niveau=0):
					    "Parcourt récursivement une structure de tuples imbriqués"
					    indent = "  " * niveau
					    
					    if isinstance(structure, tuple):
					        if structure and isinstance(structure[0], tuple):
					            print(f"{indent}Tuple de tuples (niveau {niveau}):")
					            for item in structure:
					                parcourir_tuples(item, niveau + 1)
					        else:
					            print(f"{indent}Tuple: {structure}")
					    else:
					        print(f"{indent}Valeur: {structure}")
					
					exemple_complexe = (("A", "B"), (("C", "D"), "E"), "F")
					print("Structure complexe:")
					parcourir_tuples(exemple_complexe)
					
					# 7. Modification indirecte via conversion
					print(f"\n--- Modification indirecte ---")
					
					# Conversion en listes pour modification
					structure_modifiable = [list(region) for region in regions_maroc]
					for region in structure_modifiable:
					    region[1] = [list(ville) for ville in region[1]]
					
					# Modification
					structure_modifiable[0][1][0][1] = 3400000  # Nouvelle population pour Casablanca
					
					# Reconversion en tuples
					regions_modifiees = tuple(
					    (nom_region, tuple(tuple(ville) for ville in villes))
					    for nom_region, villes in structure_modifiable
					)
					
					print(f"Population Casablanca modifiée: {regions_modifiees[0][1][0][1]:,}".replace(",", " "))

Cas d'usage pratique

Les tuples imbriqués sont particulièrement utiles dans des scénarios réels comme les systèmes de coordonnées, les configurations complexes, les structures de données hiérarchiques et les jeux de données multidimensionnels.

cas_usage_pratique.py
# Cas d'usage pratiques des tuples imbriqués
					
					# 1. Système de coordonnées géographiques
					print("--- Système géographique ---")
					
					class SystemeGeographique:
					    def __init__(self):
					        # (ville, (latitude, longitude), altitude, population)
					        self.villes = (
					            ("Casablanca", (33.5731, -7.5898), 12, 3359000),
					            ("Marrakech", (31.6295, -7.9811), 468, 928850),
					            ("Fès", (34.0333, -5.0000), 410, 1112072),
					            ("Tanger", (35.7595, -5.8340), 80, 947952)
					        )
					    
					    def trouver_ville_plus_peuplee(self):
					        "Retourne la ville la plus peuplée"
					        ville_max = None
					        population_max = -1
					        
					        for ville, coords, altitude, population in self.villes:
					            if population > population_max:
					                population_max = population
					                ville_max = ville
					        
					        return ville_max, population_max
					    
					    def calculer_distance(self, ville1, ville2):
					        "Calcule la distance approximative entre deux villes"
					        from math import radians, sin, cos, sqrt, atan2
					        
					        # Trouver les coordonnées
					        coords1 = coords2 = None
					        for ville, coords, _, _ in self.villes:
					            if ville == ville1:
					                coords1 = coords
					            if ville == ville2:
					                coords2 = coords
					        
					        if coords1 and coords2:
					            lat1, lon1 = radians(coords1[0]), radians(coords1[1])
					            lat2, lon2 = radians(coords2[0]), radians(coords2[1])
					            
					            # Formule de Haversine
					            dlat, dlon = lat2 - lat1, lon2 - lon1
					            a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
					            c = 2 * atan2(sqrt(a), sqrt(1-a))
					            distance = 6371 * c  # Rayon de la Terre en km
					            
					            return round(distance, 1)
					        
					        return None
					
					geo = SystemeGeographique()
					ville_peuplee, population = geo.trouver_ville_plus_peuplee()
					print(f"Ville la plus peuplée: {ville_peuplee} ({population:,} habitants)".replace(",", " "))
					
					distance = geo.calculer_distance("Casablanca", "Marrakech")
					print(f"Distance Casablanca-Marrakech: {distance} km")
					
					# 2. Système de réservation hôtelière
					print(f"\n--- Système de réservation ---")
					
					class SystemeReservation:
					    def __init__(self):
					        # (hôtel, ville, (prix_min, prix_max), (équipements))
					        self.hotels = (
					            ("La Mamounia", "Marrakech", (2500, 8000), ("piscine", "spa", "golf")),
					            ("Hotel Hassan", "Rabat", (800, 2000), ("wifi", "parking")),
					            ("Sofitel", "Casablanca", (1200, 3500), ("piscine", "business")),
					            ("Riad Fès", "Fès", (600, 1500), ("jardin", "terrasse"))
					        )
					    
					    def rechercher_par_ville(self, ville):
					        "Recherche les hôtels dans une ville spécifique"
					        resultats = []
					        for hotel, hotel_ville, prix, equipements in self.hotels:
					            if hotel_ville.lower() == ville.lower():
					                resultats.append((hotel, prix, equipements))
					        return resultats
					    
					    def rechercher_par_budget(self, budget_max):
					        "Recherche les hôtels dans un budget donné"
					        resultats = []
					        for hotel, ville, (prix_min, prix_max), equipements in self.hotels:
					            if prix_min <= budget_max:
					                resultats.append((hotel, ville, prix_min, equipements))
					        return resultats
					    
					    def rechercher_avec_equipement(self, equipement):
					        "Recherche les hôtels avec un équipement spécifique"
					        resultats = []
					        for hotel, ville, prix, equipements in self.hotels:
					            if equipement in equipements:
					                resultats.append((hotel, ville, prix, equipements))
					        return resultats
					
					reservation = SystemeReservation()
					
					print("Hôtels à Marrakech:")
					for hotel, prix, equipements in reservation.rechercher_par_ville("Marrakech"):
					    print(f"  - {hotel}: {prix[0]}-{prix[1]} DH, Équipements: {', '.join(equipements)}")
					
					print(f"\nHôtels avec piscine:")
					for hotel, ville, prix, equipements in reservation.rechercher_avec_equipement("piscine"):
					    print(f"  - {hotel} ({ville}): {prix[0]}-{prix[1]} DH")
					
					# 3. Système éducatif
					print(f"\n--- Système éducatif ---")
					
					class SystemeEducatif:
					    def __init__(self):
					        # (université, ville, (fondation, étudiants), [facultés])
					        self.universites = (
					            ("Université Mohammed V", "Rabat", (1957, 45000), 
					             ("Droit", "Médecine", "Sciences")),
					            ("Université Cadi Ayyad", "Marrakech", (1978, 65000),
					             ("Sciences", "Lettres", "Droit")),
					            ("Université Hassan II", "Casablanca", (1975, 55000),
					             ("Économie", "Médecine", "Ingénierie"))
					        )
					    
					    def statistiques(self):
					        "Calcule des statistiques sur le système éducatif"
					        total_etudiants = 0
					        universites_par_ville = {}
					        facultees_uniques = set()
					        
					        for universite, ville, (fondation, etudiants), facultes in self.universites:
					            total_etudiants += etudiants
					            universites_par_ville[ville] = universites_par_ville.get(ville, 0) + 1
					            facultees_uniques.update(facultes)
					        
					        return {
					            "total_etudiants": total_etudiants,
					            "universites_par_ville": universites_par_ville,
					            "nombre_facultes": len(facultees_uniques),
					            "moyenne_etudiants": total_etudiants // len(self.universites)
					        }
					    
					    def rechercher_par_faculte(self, faculte):
					        "Trouve les universités offrant une faculté spécifique"
					        resultats = []
					        for universite, ville, (fondation, etudiants), facultes in self.universites:
					            if faculte in facultes:
					                resultats.append((universite, ville, etudiants, fondation))
					        return resultats
					
					education = SystemeEducatif()
					stats = education.statistiques()
					print("Statistiques éducatives:")
					print(f"  Total étudiants: {stats['total_etudiants']:,}".replace(",", " "))
					print(f"  Universités par ville: {stats['universites_par_ville']}")
					print(f"  Nombre de facultés différentes: {stats['nombre_facultes']}")
					print(f"  Moyenne d'étudiants par université: {stats['moyenne_etudiants']:,}".replace(",", " "))
					
					print(f"\nUniversités avec faculté de Médecine:")
					for universite, ville, etudiants, fondation in education.rechercher_par_faculte("Médecine"):
					    print(f"  - {universite} ({ville}), fondée en {fondation}, {etudiants:,} étudiants".replace(",", " "))
					
					# 4. Jeu d'échecs avec tuples imbriqués
					print(f"\n--- Jeu d'échecs ---")
					
					class Echiquier:
					    def __init__(self):
					        # Représentation de l'échiquier avec tuples imbriqués
					        # Chaque pièce est représentée par (type, couleur)
					        self.echiquier = (
					            (("tour", "noir"), ("cavalier", "noir"), ("fou", "noir"), ("reine", "noir"),
					             ("roi", "noir"), ("fou", "noir"), ("cavalier", "noir"), ("tour", "noir")),
					            (("pion", "noir"),) * 8,
					            ((None, None),) * 8,
					            ((None, None),) * 8,
					            ((None, None),) * 8,
					            ((None, None),) * 8,
					            (("pion", "blanc"),) * 8,
					            (("tour", "blanc"), ("cavalier", "blanc"), ("fou", "blanc"), ("reine", "blanc"),
					             ("roi", "blanc"), ("fou", "blanc"), ("cavalier", "blanc"), ("tour", "blanc"))
					        )
					    
					    def afficher(self):
					        "Affiche l'échiquier"
					        print("  a b c d e f g h")
					        print("  ---------------")
					        for i, ligne in enumerate(self.echiquier):
					            print(8-i, end=" ")
					            for case in ligne:
					                if case[0] is None:
					                    print(". ", end="")
					                else:
					                    symbole = case[0][0].upper() if case[1] == "blanc" else case[0][0]
					                    print(f"{symbole} ", end="")
					            print(8-i)
					        print("  ---------------")
					        print("  a b c d e f g h")
					    
					    def obtenir_piece(self, ligne, colonne):
					        "Retourne la pièce à une position donnée"
					        return self.echiquier[ligne][colonne]
					
					jeu = Echiquier()
					jeu.afficher()
					
					piece = jeu.obtenir_piece(0, 0)
					print(f"\nPièce en a8: {piece[0]} {piece[1]}")
					
					# 5. Avantages des tuples imbriqués
					print(f"\n--- Avantages des tuples imbriqués ---")
					
					print("✓ Immutabilité garantie")
					print("✓ Performance mémoire")
					print("✓ Hachage possible pour les clés de dictionnaire")
					print("✓ Structure de données prédictible")
					print("✓ Parfait pour les configurations et constantes")

Avantages et cas d'utilisation des tuples

Les tuples offrent des avantages significatifs par rapport aux listes dans des scénarios spécifiques. Leur immutabilité, leur performance et leur capacité à servir de clés de dictionnaire en font des structures de données précieuses pour de nombreuses applications.

Tuples comme clés de dictionnaire

Contrairement aux listes, les tuples peuvent être utilisés comme clés de dictionnaire car ils sont immuables et donc hachables. Cette propriété permet de créer des structures de données complexes et efficaces.

tuples_cles_dictionnaire.py
# Utilisation des tuples comme clés de dictionnaire
					
					# 1. Clés simples avec coordonnées géographiques
					print("--- Clés avec coordonnées ---")
					
					# Dictionnaire utilisant des tuples (latitude, longitude) comme clés
					villes_par_coordonnees = {
					    (33.5731, -7.5898): "Casablanca",
					    (34.0209, -6.8416): "Rabat",
					    (31.6295, -7.9811): "Marrakech",
					    (34.0333, -5.0000): "Fès"
					}
					
					print("Villes par coordonnées:")
					for coords, ville in villes_par_coordonnees.items():
					    print(f"  {coords} → {ville}")
					
					# Recherche rapide par coordonnées
					coords_recherche = (31.6295, -7.9811)
					print(f"\nVille aux coordonnées {coords_recherche}: {villes_par_coordonnees.get(coords_recherche, 'Non trouvée')}")
					
					# 2. Clés composites pour un système de réservation
					print(f"\n--- Système de réservation ---")
					
					class SystemeReservation:
					    def __init__(self):
					        # Clé: (ville_départ, ville_arrivée, date)
					        # Valeur: (prix, places_disponibles, compagnie)
					        self.vols = {
					            ("Casablanca", "Marrakech", "2024-03-15"): (450, 12, "Royal Air Maroc"),
					            ("Rabat", "Agadir", "2024-03-16"): (520, 8, "Air Arabia"),
					            ("Fès", "Casablanca", "2024-03-17"): (380, 15, "Royal Air Maroc"),
					            ("Marrakech", "Tanger", "2024-03-18"): (610, 5, "Ryanair")
					        }
					    
					    def rechercher_vol(self, depart, arrivee, date):
					        cle = (depart, arrivee, date)
					        return self.vols.get(cle)
					    
					    def reserver_vol(self, depart, arrivee, date, passagers=1):
					        cle = (depart, arrivee, date)
					        if cle in self.vols:
					            prix, places, compagnie = self.vols[cle]
					            if places >= passagers:
					                # Mise à jour des places disponibles
					                self.vols[cle] = (prix, places - passagers, compagnie)
					                return True, f"Réservation confirmée! Total: {prix * passagers} DH"
					            else:
					                return False, "Places insuffisantes"
					        return False, "Vol non trouvé"
					
					reservation = SystemeReservation()
					
					print("Recherche d'un vol:")
					vol = reservation.rechercher_vol("Casablanca", "Marrakech", "2024-03-15")
					if vol:
					    prix, places, compagnie = vol
					print(f"  {compagnie}: {prix} DH, {places} places")
					
					success, message = reservation.reserver_vol("Casablanca", "Marrakech", "2024-03-15", 2)
					print(f"\nRéservation: {message}")
					
					# 3. Cache avec tuples comme clés
					print(f"\n--- Système de cache ---")
					
					class CacheCalculs:
					    def __init__(self):
					        self.cache = {}
					    
					    def calculer_distance(self, ville1, ville2, unite="km"):
					        "Calcule la distance entre deux villes avec cache"
					        cle = (ville1, ville2, unite)
					        
					        # Vérifier le cache
					        if cle in self.cache:
					            print(f"  [CACHE] Distance {ville1}-{ville2}")
					            return self.cache[cle]
					        
					        # Simulation d'un calcul coûteux
					        distances = {
					            ("Casablanca", "Marrakech"): 240,
					            ("Rabat", "Fès"): 200,
					            ("Marrakech", "Agadir"): 170
					        }
					        
					        distance_base = distances.get((ville1, ville2), 0)
					        
					        # Conversion d'unité
					        if unite == "miles":
					            resultat = distance_base * 0.621371
					        else:
					            resultat = distance_base
					        
					        # Mettre en cache
					        self.cache[cle] = resultat
					        print(f"  [CALCUL] Distance {ville1}-{ville2}")
					        return resultat
					
					cache_calc = CacheCalculs()
					
					print("Calculs de distances:")
					print(f"  Casablanca-Marrakech: {cache_calc.calculer_distance('Casablanca', 'Marrakech')} km")
					print(f"  Casablanca-Marrakech: {cache_calc.calculer_distance('Casablanca', 'Marrakech')} km")  # Utilise le cache
					print(f"  Casablanca-Marrakech: {cache_calc.calculer_distance('Casablanca', 'Marrakech', 'miles')} miles")
					
					# 4. Configuration système avec tuples imbriqués
					print(f"\n--- Configuration système ---")
					
					# Configuration utilisant des tuples imbriqués comme clés
					config_systeme = {
					    ("database", "host"): "localhost",
					    ("database", "port"): 5432,
					    ("api", "timeout"): 30,
					    ("api", "retries"): 3,
					    ("logging", "level"): "INFO",
					    (("security", "ssl"), "enabled"): True
					}
					
					print("Configuration système:")
					for cle, valeur in config_systeme.items():
					    print(f"  {cle} = {valeur}")
					
					# Accès hiérarchique
					print(f"\nPort de la base de données: {config_systeme[('database', 'port')]}")
					
					# 5. Avantages des tuples comme clés
					print(f"\n--- Avantages ---")
					
					print("✓ Hachables (immuables)")
					print("✓ Clés composites naturelles")
					print("✓ Performance de recherche O(1)")
					print("✓ Structure de données prédictible")
					print("✓ Parfaits pour le caching")

Retour multiple dans une fonction

Les tuples permettent aux fonctions de retourner plusieurs valeurs de manière naturelle et élégante. Cette fonctionnalité est largement utilisée dans les bibliothèques Python et les applications réelles.

retour_multiple.py
# Retour multiple de valeurs avec des tuples
					
					# 1. Retour multiple basique
					print("--- Retour multiple basique ---")
					
					def analyser_ville(ville):
					    "Analyse une ville et retourne plusieurs statistiques"
					    donnees = {
					        "Casablanca": (3359000, "économique", 33.5731, -7.5898),
					        "Marrakech": (928850, "touristique", 31.6295, -7.9811),
					        "Fès": (1112072, "culturel", 34.0333, -5.0000)
					    }
					    
					    if ville in donnees:
					        population, type_ville, lat, lon = donnees[ville]
					        return population, type_ville, (lat, lon)
					    else:
					        return 0, "inconnu", (0, 0)
					
					# Utilisation avec déballage
					population, type_ville, coords = analyser_ville("Casablanca")
					print(f"Casablanca: {population:,} habitants, type: {type_ville}".replace(",", " "))
					print(f"Coordonnées: {coords}")
					
					# 2. Retour de statuts complexes
					print(f"\n--- Retour de statuts ---")
					
					def traiter_commande(produit, quantite):
					    "Traite une commande et retourne un statut détaillé"
					    stock = {
					        "Huile d'Argan": 50,
					        "Tapis Berbère": 10,
					        "Thé Marocain": 100
					    }
					    
					    prix = {
					        "Huile d'Argan": 150.0,
					        "Tapis Berbère": 1200.0,
					        "Thé Marocain": 45.0
					    }
					    
					    if produit not in stock:
					        return False, "Produit non disponible", 0, 0
					    
					    if quantite > stock[produit]:
					        return False, "Stock insuffisant", stock[produit], 0
					    
					    total = quantite * prix[produit]
					    stock[produit] -= quantite
					    
					    return True, "Commande traitée", quantite, total
					
					# Traitement de commandes
					commandes = [
					    ("Huile d'Argan", 2),
					    ("Tapis Berbère", 15),  # Stock insuffisant
					    ("Produit Inexistant", 1)   # Produit non disponible
					]
					
					print("Traitement des commandes:")
					for produit, quantite in commandes:
					    success, message, qte_traitee, total = traiter_commande(produit, quantite)
					    statut = "✓ SUCCÈS" if success else "✗ ÉCHEC"
					    print(f"  {statut} {produit}: {message}")
					    if success:
					        print(f"     Quantité: {qte_traitee}, Total: {total} DH")
					
					# 3. Retour pour le traitement d'erreurs
					print(f"\n--- Traitement d'erreurs ---")
					
					def valider_utilisateur(email, mot_de_passe):
					    "Valide un utilisateur et retourne un tuple de statut"
					    
					    # Simuler une base de données
					    utilisateurs = {
					        "admin@maroc.ma": ("admin123", "admin", True),
					        "client@example.com": ("pass123", "client", True),
					        "inactif@test.ma": ("test123", "client", False)
					    }
					    
					    if email not in utilisateurs:
					        return False, "Utilisateur non trouvé", None, None
					    
					    mdp_stocke, role, actif = utilisateurs[email]
					    
					    if not actif:
					        return False, "Compte désactivé", role, email
					    
					    if mdp_stocke != mot_de_passe:
					        return False, "Mot de passe incorrect", role, email
					    
					    return True, "Authentification réussie", role, email
					
					# Tests d'authentification
					tests = [
					    ("admin@maroc.ma", "admin123"),
					    ("client@example.com", "wrongpass"),
					    ("inactif@test.ma", "test123"),
					    ("inexistant@test.ma", "anypass")
					]
					
					print("Tests d'authentification:")
					for email, mdp in tests:
					    success, message, role, user_email = valider_utilisateur(email, mdp)
					    statut = "? CONNECTÉ" if success else "? REFUSÉ"
					    print(f"  {statut} {email}: {message}")
					    if success:
					        print(f"     Rôle: {role}")
					
					# 4. Retour pour les opérations de traitement de données
					print(f"\n--- Traitement de données ---")
					
					def analyser_ventes(ventes):
					    "Analyse des ventes et retourne des statistiques complètes"
					    if not ventes:
					        return 0, 0, 0, 0, []
					    
					    total = sum(ventes)
					    moyenne = total / len(ventes)
					    maximum = max(ventes)
					    minimum = min(ventes)
					    
					    # Ventes au-dessus de la moyenne
					    ventes_sup_moyenne = [v for v in ventes if v > moyenne]
					    
					    return total, moyenne, maximum, minimum, ventes_sup_moyenne
					
					# Analyse des ventes mensuelles
					ventes_trimestre = [125000, 98000, 156000, 142000]
					total, moyenne, maxi, mini, sup_moyenne = analyser_ventes(ventes_trimestre)
					
					print("Analyse des ventes trimestrielles:")
					print(f"  Total: {total:,} DH".replace(",", " "))
					print(f"  Moyenne: {moyenne:,.0f} DH".replace(",", " "))
					print(f"  Maximum: {maxi:,} DH".replace(",", " "))
					print(f"  Minimum: {mini:,} DH".replace(",", " "))
					print(f"  Ventes supérieures à la moyenne: {len(sup_moyenne)}")
					
					# 5. Avantages du retour multiple
					print(f"\n--- Avantages ---")
					
					print("✓ Code plus lisible et concis")
					print("✓ Évite la création de classes simples")
					print("✓ Naturel pour les opérations multiples")
					print("✓ Compatible avec le déballage")
					print("✓ Standard Pythonique")

Meilleure performance et sécurité des données

Les tuples offrent des avantages significatifs en termes de performance et de sécurité grâce à leur immutabilité. Ils sont plus rapides à traiter et garantissent l'intégrité des données.

performance_securite.py
# Performance et sécurité des tuples
					
					# 1. Comparaison de performance
					print("--- Comparaison de performance ---")
					
					import sys
					import time
					import timeit
					
					# Comparaison de la taille mémoire
					villes_liste = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"]
					villes_tuple = ("Casablanca", "Rabat", "Marrakech", "Fès", "Tanger")
					
					print("Comparaison de taille mémoire:")
					print(f"  Liste: {sys.getsizeof(villes_liste)} octets")
					print(f"  Tuple: {sys.getsizeof(villes_tuple)} octets")
					print(f"  Économie: {sys.getsizeof(villes_liste) - sys.getsizeof(villes_tuple)} octets")
					
					# Comparaison de vitesse d'accès
					print(f"\nComparaison de vitesse d'accès:")
					
					# Test d'accès par index
					temps_liste = timeit.timeit('villes_liste[2]', globals=globals(), number=1000000)
					temps_tuple = timeit.timeit('villes_tuple[2]', globals=globals(), number=1000000)
					print(f"  Accès liste: {temps_liste:.6f} secondes (1M d'opérations)")
					print(f"  Accès tuple: {temps_tuple:.6f} secondes (1M d'opérations)")
					print(f"  Gain: {((temps_liste - temps_tuple) / temps_liste * 100):.1f}%")
					
					# 2. Sécurité des données constantes
					print(f"\n--- Sécurité des données ---")
					
					class SystemeConfiguration:
					    # Configuration immuable utilisant des tuples
					    CONFIG_PAR_DEFAUT = (
					        ("database", "localhost", 5432),
					        ("api", 30, 3),  # timeout, retries
					        ("security", True, True)  # ssl, authentication
					    )
					    
					    # Constantes métier
					    TAUX_TVA = (0.20, 0.14, 0.10)  # TVA normale, réduite, super-réduite
					    DEVISE = ("MAD", "DH")  # Code, symbole
					    
					    def __init__(self):
					        self.config_actuelle = self.CONFIG_PAR_DEFAUT
					    
					    def afficher_config(self):
					        print("Configuration système:")
					for section in self.config_actuelle:
					            print(f"  {section}")
					    
					    def calculer_tva(self, montant, type_tva="normale"):
					        types = {"normale": 0, "réduite": 1, "super-réduite": 2}
					        taux = self.TAUX_TVA[types.get(type_tva, 0)]
					        return montant * taux
					
					config = SystemeConfiguration()
					config.afficher_config()
					
					print(f"\nCalcul de TVA (normale): {config.calculer_tva(1000):.2f} {config.DEVISE[1]}")
					print(f"Calcul de TVA (réduite): {config.calculer_tva(1000, 'réduite'):.2f} {config.DEVISE[1]}")
					
					# Tentative de modification (échouera)
					print(f"\nTentative de modification de la configuration...")
					try:
					    config.CONFIG_PAR_DEFAUT[0] = ("modified", "value")
					except TypeError as e:
					print(f"  Erreur: {e}")
					print("  ✓ Configuration protégée contre les modifications accidentelles")
					
					# 3. Performance dans les boucles
					print(f"\n--- Performance dans les boucles ---")
					
					# Données de test
					donnees_liste = [i for i in range(10000)]
					donnees_tuple = tuple(i for i in range(10000))
					
					# Test d'itération
					debut = time.time()
					for item in donnees_liste:
					    pass
					temps_liste_iter = time.time() - debut
					
					debut = time.time()
					for item in donnees_tuple:
					    pass
					temps_tuple_iter = time.time() - début
					
					print("Performance d'itération (10,000 éléments):")
					print(f"  Liste: {temps_liste_iter:.6f} secondes")
					print(f"  Tuple: {temps_tuple_iter:.6f} secondes")
					print(f"  Différence: {(temps_tuple_iter - temps_liste_iter) * 1000:.2f} ms")
					
					# 4. Sécurité dans le partage de données
					print(f"\n--- Sécurité dans le partage ---")
					
					class SystemeAuthentification:
					    def __init__(self):
					        # Rôles et permissions immuables
					        self.PERMISSIONS = (
					            ("admin", ("lecture", "écriture", "suppression", "administration")),
					            ("utilisateur", ("lecture", "écriture")),
					            ("invité", ("lecture",))
					        )
					    
					    def verifier_permission(self, role, permission):
					        "Vérifie si un rôle a une permission spécifique"
					        for r, permissions in self.PERMISSIONS:
					            if r == role:
					                return permission in permissions
					        return False
					    
					    def afficher_roles(self):
					        print("Rôles et permissions:")
					for role, permissions in self.PERMISSIONS:
					            print(f"  {role}: {', '.join(permissions)}")
					
					auth = SystemeAuthentification()
					auth.afficher_roles()
					
					print(f"\nVérifications de permissions:")
					print(f"  Admin peut supprimer: {auth.verifier_permission('admin', 'suppression')}")
					print(f"  Utilisateur peut administrer: {auth.verifier_permission('utilisateur', 'administration')}")
					print(f"  Invité peut écrire: {auth.verifier_permission('invité', 'écriture')}")
					
					# 5. Cas d'optimisation réelle
					print(f"\n--- Optimisation réelle ---")
					
					class AnalyseurPerformance:
					    def __init__(self):
					        # Données de référence immuables
					        self.SEUILS_ALERTE = (
					            ("CRITIQUE", 95.0, "red"),
					            ("ÉLEVÉ", 80.0, "orange"),
					            ("MOYEN", 65.0, "yellow"),
					            ("FAIBLE", 50.0, "green")
					        )
					    
					    def analyser_performance(self, utilisation_cpu):
					        "Analyse la performance et retourne le niveau d'alerte"
					        for niveau, seuil, couleur in self.SEUILS_ALERTE:
					            if utilisation_cpu >= seuil:
					                return niveau, couleur, utilisation_cpu
					        return "NORMAL", "blue", utilisation_cpu
					    
					    def generer_rapport(self, *mesures):
					        print("Rapport de performance:")
					for mesure in mesures:
					            niveau, couleur, valeur = self.analyser_performance(mesure)
					            print(f"  CPU {valeur}% → {niveau} ({couleur})")
					
					performance = AnalyseurPerformance()
					performance.generer_rapport(45, 67, 82, 96)
					
					# 6. Résumé des avantages
					print(f"\n--- Résumé des avantages ---")
					
					print("? PERFORMANCE:")
					print("  ✓ Allocation mémoire plus efficace")
					print("  ✓ Accès plus rapide aux éléments")
					print("  ✓ Meilleure performance en itération")
					print("  ✓ Optimisation du cache processeur")
					
					print(f"\n? SÉCURITÉ:")
					print("  ✓ Données protégées contre les modifications")
					print("  ✓ Intégrité des constantes garantie")
					print("  ✓ Partage sécurisé entre threads")
					print("  ✓ Prévention des bugs liés aux mutations")
					
					print(f"\n? UTILISATION RECOMMANDÉE:")
					print("  ✓ Données constantes et configurations")
					print("  ✓ Clés de dictionnaire")
					print("  ✓ Retour multiple de fonctions")
					print("  ✓ Données en lecture seule")
					print("  ✓ Structures de données immuables")
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!